home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / HDX_BACK / HDLFILE / HDLFILE.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-09  |  28.2 KB  |  1,420 lines
  1. #include "osbind.h"
  2. #include "obdefs.h"
  3. #include "gemdefs.h"
  4. #include "stat.h"
  5. #include "hdl.h"
  6.  
  7.  
  8. #define OK         1
  9. #define FALSE   -1
  10. #define ERROR   -1
  11. #define FTOF    1
  12. #define FTOD    2
  13. #define DTOD    3
  14. #define DIRLEN  8
  15. #define FILELEN 12
  16.  
  17. OBJECT     *cpbox;            /* cp or rm or mv dialog box */
  18. OBJECT     *samename;        /* name conflict dialog box */
  19. char     *cntopen;        /* can't open file alert box */
  20. char    *cntcrtdr;        /* can't create directory alert box */
  21. char    *cntcrtfl;        /* can't create file alert box */
  22. char    *cntdelf;        /* can't delete file alert box */
  23. char    *cntdeld;        /* can't delete directory alert box */
  24. char    *wrerror;        /* write file error alert box */
  25. char    *rderror;        /* read file error alert box */
  26. char    *nomemory;        /* not sufficient memory alert box */
  27.  
  28. int  srclen, dstlen;    /* the size of source and target buffer */
  29. long numfiles = 0L;        /* the number of files show in the dialog box */
  30. long numdirs = 0L;        /* the number of directories */
  31. long tolsize = 0L;        /* the total size of all files in the path */
  32. int  srcbuf, dstbuf;    /* the size of source and target buffer be define */
  33. int     editdir;            /* the flag for the user edit the name conflict */
  34. char *fixsrc, *fixdst;    /* the source and target string pointer */
  35. long _stksize = 25000;    /* resize the stack size */
  36. char *getall = "*.*";
  37. char *bckslsh = "\\\0";
  38.  
  39. /* AES (windows and messages) related variables */
  40. int formw, formh, sx, sy, lx, ly;    /* dialogue box dimensions */
  41. int hdesk, wdesk;                    /* window X, Y, width, height */
  42.  
  43. char *filestr = "abcdefgh.abcb";    /* the buffer for the file */
  44. char *cptitle = " COPY FILE(S) ";    /* the title for the cp dialog box */
  45. char *mvtitle = " MOVE FILE(S) ";    /* the title for the mv dialog box */
  46. char *rmtitle = "DELETE FILE(S)";    /* the title for the rm dialog box */
  47.  
  48.  
  49. main(argc, argv) 
  50.  
  51. int argc;
  52. char **argv;
  53.  
  54. {
  55.     char *convert();
  56.     char *src, *dst;
  57.     long ndirs,nfiles,tsize;
  58.  
  59.     if(argc < 4)    {
  60.         Cconws("Usage: hdlfile source destination code\r\n");
  61.         Pterm0();
  62.     }
  63.     convert(&src, argv[1]);
  64.     convert(&dst, argv[2]);
  65.     dofiles(src, dst, atoi(argv[3]), &ndirs, &nfiles, &tsize);
  66.  
  67. }
  68.  
  69. char *
  70. convert(ret, src)
  71. char **ret;
  72. char *src;
  73. {
  74.     char *tmp, *tmp1;
  75.  
  76.     tmp1 = (char *)Malloc((long)(sizeof(src)+10));
  77.     strcpy(src, tmp1);
  78.     tmp = tmp1;
  79.     while(*tmp)    ++tmp;
  80.     if (*(tmp-1) == 'a')    {
  81.         *(tmp-1) = '\0';
  82.         strcat("*.*", tmp1);
  83.     }
  84.     *ret = tmp1;
  85. }
  86.  
  87. d_next(s)
  88. char **s;
  89. { 
  90.     *s = fixdst;
  91.     return (0); 
  92. }
  93.  
  94. dofiles(s, d, code, ndirs, nfiles, tsize)
  95.  
  96. char *s, *d;
  97. int code;
  98. long *ndirs, *nfiles, *tsize;
  99.  
  100. {
  101.  
  102.     /* 
  103.     extern int d_next();
  104.     */
  105.  
  106.     if (code == 3)    {    /* do for information use */
  107.         count(s);
  108.         *ndirs = numdirs;
  109.         *nfiles = numfiles;
  110.         *tsize = tolsize;
  111.         return OK;
  112.     }
  113.     appl_init();
  114.     if (!rsrc_load("HDL.RSC"))    {
  115.         goto cleanup;
  116.     }
  117.  
  118.     if (getalladdr() != OK)        {
  119.         goto cleanup;
  120.     }
  121.  
  122.     do    {
  123.         count(s);
  124.         if (!code)    {                /* do rm files and dirs */
  125.             rmfile(getinfo(s, d, code));
  126.         } else if (code == 1)    {    /* do cp files and dirs */
  127.             cpfile(getinfo(s, d, code));
  128.         } else     {                    /* do rm files and dirs */
  129.             mvfile(getinfo(s, d, code));
  130.         } 
  131.     } while (d_next(&s));
  132.  
  133. cleanup:
  134.     appl_exit();
  135.     return OK;
  136. }
  137.  
  138.  
  139. /* do the rm file job */
  140.  
  141. rmfile(flag)
  142. int flag;
  143.  
  144. {
  145.  
  146.     int ret;
  147.  
  148.     if (showbox(rmtitle) == CANCEL)        {
  149.         goto endrm;
  150.     }
  151.     if (flag == FTOD)     {     /* one file from dir rm */
  152.         updatedir();
  153.         updatefile();
  154.     redel:
  155.         if ((ret = Fdelete(fixsrc)))    {
  156.             if ((ret == 0xFFFA) || (ret == 0xFFFE))    { /* seek error or */
  157.                 Pterm(1);                              /* drive not ready */
  158.             }
  159.             if (err(cntdelf) == 2)    {    /* retry */
  160.                 goto redel;
  161.             } else {                    /* quit */
  162.                 goto endrm;
  163.             }
  164.         }
  165.     } else {                    /* rm dir or files */
  166.         fixdst = fixsrc;
  167.         dormfd();
  168.     }
  169.  
  170. endrm:
  171.     erasemsg();
  172.     Mfree(fixsrc);
  173.     Mfree(fixdst);
  174.     return OK;
  175. }
  176.  
  177.  
  178. /* do the cp file job */
  179.  
  180. cpfile(flag)
  181.  
  182. int flag;
  183.  
  184. {
  185.  
  186.     if (showbox(cptitle) == CANCEL)        {
  187.         goto endcp;
  188.     }
  189.     if (flag == DTOD)     {    /* files and directories cp */
  190.         docpfd();
  191.     } else {                /* a file cp */
  192.         updatedir();
  193.         updatefile();
  194.         wrfile(fixsrc, fixdst);
  195.     }
  196.  
  197. endcp:
  198.     erasemsg();
  199.     Mfree(fixsrc);
  200.     Mfree(fixdst);
  201.     return OK;
  202. }
  203.  
  204.  
  205.  
  206. /* do the mv file job */
  207.  
  208. mvfile(flag)
  209. int flag;
  210.  
  211. {
  212.  
  213.     if (showbox(mvtitle) == CANCEL)        {
  214.         goto endmv;
  215.     }
  216.     if (flag == DTOD)    {    /* files and directories mv */
  217.         domvfd();
  218.     } else {                /* a file mv */
  219.         updatedir();
  220.         updatefile();
  221.         wrfile(fixsrc, fixdst);
  222.     remvdel:
  223.         if (Fdelete(fixsrc))    {
  224.             if (err(cntdelf) == 2)    {    /* retry */
  225.                 goto remvdel;
  226.             } else {                    /* quit */
  227.                 goto endmv;
  228.             }
  229.         }
  230.     }
  231.  
  232. endmv:
  233.     erasemsg();
  234.     Mfree(fixsrc);
  235.     Mfree(fixdst);
  236.     return OK;
  237. }
  238.  
  239.  
  240.  
  241.  
  242.  
  243. /* recursively rm dir or files form a given path */
  244.  
  245. dormfd()
  246.  
  247. {
  248.     char *saved;
  249.     extern char *strcat();
  250.     extern char *strcpy();
  251.     DMABUFFER dumb;
  252.     int ret;
  253.  
  254.     saved = (DMABUFFER *)Fgetdta();
  255.     Fsetdta(&dumb);
  256.     strcat(getall, fixsrc);
  257.     if (!Fsfirst(fixsrc, 0xFF))    {
  258.         do     {
  259.             if (dumb.d_fname[0] != '.')    {
  260.                 if (S_IFDIR & dumb.d_fattr)    {
  261.                     chksrcbuf(DIRLEN);        /* check buf size */
  262.                     addfile(fixsrc, dumb.d_fname);/* add a dir to the path */
  263.                     strcat(bckslsh, fixsrc);
  264.                     dormfd();                /* to the recursion */
  265.                     rmstarb(fixsrc);        /* rm the star and back slash */
  266.                     getlastpath(filestr, fixsrc); 
  267.                     unpack(filestr);
  268.                     strcpy(filestr,
  269.                             ((TEDINFO *)(cpbox[CPDIR].ob_spec))->te_ptext); 
  270.                     strcpy("_", ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext);
  271.                     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  272.                     objc_draw(cpbox, CPDIR, MAX_DEPTH, 0, 0, wdesk, hdesk);
  273.                     /* delete a dir from source */
  274.                 redeld:
  275.                     if (Ddelete(fixsrc))    {
  276.                         if ((ret = err(cntdeld)) == 2)    { /* retry */
  277.                             goto redeld;
  278.                         } else if (ret == 3)    {         /* abort */
  279.                             Pterm(1);
  280.                         }
  281.                     }
  282.                     backdir(fixsrc);        /* back one dir */
  283.                     updatndir();
  284.                     srclen -= DIRLEN;        /* subtract the add lenth */
  285.  
  286.                 } else {
  287.                     chksrcbuf(FILELEN);        /* check buf size */
  288.                     addfile(fixsrc, dumb.d_fname);
  289.                     updatedir();
  290.                     /* update the file box */
  291.                     unpack(dumb.d_fname); 
  292.                     strcpy(dumb.d_fname,
  293.                             ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext); 
  294.                     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  295.                 redelf:
  296.                     if ((ret = Fdelete(fixsrc)))    {
  297.                         if ((ret == 0xFFFA) || (ret == 0xFFFE))    { 
  298.                             /* seek error or  drive not ready */
  299.                             Pterm(1);                              
  300.                         }
  301.                         if ((ret = err(cntdelf)) == 2)    {    /* retry */
  302.                             goto redelf;
  303.                         } else if (ret == 3)    {            /* abort */
  304.                             Pterm(1);
  305.                         }
  306.                     }
  307.                     updatnfile();
  308.                     backdir(fixsrc);
  309.                     srclen -= FILELEN;        /* subtract the add lenth */
  310.                 }
  311.             } 
  312.         } while (!Fsnext());
  313.     } else {
  314.         Pterm(1);
  315.     }
  316.     Fsetdta(saved);
  317.     return OK;
  318. }
  319.  
  320.  
  321.  
  322. /* recursively cp files and directories from the given path */
  323.  
  324.  
  325. docpfd()
  326.  
  327. {
  328.     char *saved;
  329.     extern char *strcat();
  330.     extern char *strcpy();
  331.     DMABUFFER dumb;
  332.     int ret, code;
  333.  
  334.     saved = (DMABUFFER *)Fgetdta();
  335.     Fsetdta(&dumb);
  336.     strcat(getall, fixsrc);
  337.     if (!Fsfirst(fixsrc, 0xFF))    {
  338.         do     {
  339.             if (dumb.d_fname[0] != '.')    {
  340.                 if (S_IFDIR & dumb.d_fattr)    {
  341.                     chksrcbuf(DIRLEN);        /* check buf size */
  342.                     addfile(fixsrc, dumb.d_fname);/* add a dir to the path */
  343.                     strcat(bckslsh, fixsrc);
  344.                     chkdstbuf(DIRLEN);        /* check buf size */
  345.                     strcat(dumb.d_fname, fixdst);
  346.                     unpack(dumb.d_fname);
  347.                     strcpy(dumb.d_fname,
  348.                             ((TEDINFO *)(cpbox[CPDIR].ob_spec))->te_ptext);
  349.                     strcpy("_", ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext);
  350.                     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  351.                     objc_draw(cpbox, CPDIR, MAX_DEPTH, 0, 0, wdesk, hdesk);
  352.                     /* update check the dir existing or not */
  353.                     if ((code = chkdir(dumb.d_fname, cpbox)) == QUIT)    {
  354.                         Pterm(1);
  355.                     } else if (code == SKIP)    {
  356.                         /* update the number of dir */
  357.                         updatndir();
  358.                         backdir(fixsrc);
  359.                         backdir(fixdst);
  360.                         srclen -= DIRLEN;        /* subtract the add lenth */
  361.                         dstlen -= DIRLEN;        /* subtract the add lenth */
  362.                         continue;
  363.                     }
  364.  
  365.                     if ((editdir) || (code == OK))    {
  366.                     recreate:
  367.                         if (Dcreate(fixdst))    {
  368.                             if ((ret = err(cntcrtdr)) == 1)    {    /* skip */
  369.                                 backdir(fixsrc);
  370.                                 backdir(fixdst);
  371.                                 srclen -= DIRLEN;    /* subtract the add lenth */
  372.                                 dstlen -= DIRLEN;    /* subtract the add lenth */
  373.                                 /* update the number of dir */
  374.                                 updatndir();
  375.                                 continue;
  376.                             } else if (ret == 2)    {    /* retry */
  377.                                 goto recreate;
  378.                             } else     {                    /* quit */
  379.                                 Pterm(1);
  380.                             }
  381.                         }
  382.                     }
  383.                     /* update the number of dir */
  384.                     updatndir();
  385.                     strcat(bckslsh, fixdst);/* fixdst -> c:\d1\d2\ */
  386.                     docpfd();                /* do the recursion */
  387.                     backdir(fixsrc);        /* back one dir */
  388.                     backdir(fixdst);        /* back one dir */
  389.                     srclen -= DIRLEN;        /* subtract the add lenth */
  390.                     dstlen -= DIRLEN;        /* subtract the add lenth */
  391.  
  392.                 } else {
  393.                     chksrcbuf(FILELEN);        /* check buf size */
  394.                     addfile(fixsrc, dumb.d_fname);
  395.                     chkdstbuf(FILELEN);        /* check buf size */
  396.                     addfile(fixdst, dumb.d_fname);
  397.                     updatedir();             /* update the folder */
  398.                     /* update the file box */
  399.                     unpack(dumb.d_fname); 
  400.                     strcpy(dumb.d_fname,
  401.                             ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext); 
  402.                     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  403.                     wrfile(fixsrc, fixdst);    /* cp a file to the destination */
  404.                     backdir(fixsrc);        /* back one dir */
  405.                     backdir(fixdst);        /* back one dir */
  406.                     srclen -= FILELEN;        /* subtract the add lenth */
  407.                     dstlen -= FILELEN;        /* subtract the add lenth */
  408.                 }
  409.             } 
  410.         } while (!Fsnext());
  411.     } else {
  412.         Pterm(1);
  413.     }
  414.     Fsetdta(saved);
  415.     return OK;
  416. }
  417.  
  418.  
  419. /* recursively mv files or directoies from a given path */
  420.  
  421.  
  422. domvfd()
  423.  
  424.  
  425. {
  426.     char *saved;
  427.     extern char *strcat();
  428.     extern char *strcpy();
  429.     DMABUFFER dumb;
  430.     int ret, code;
  431.  
  432.     saved = (DMABUFFER *)Fgetdta();
  433.     Fsetdta(&dumb);
  434.     strcat(getall, fixsrc);
  435.     if (!Fsfirst(fixsrc, 0xFF))    {
  436.         do     {
  437.             if (dumb.d_fname[0] != '.')    {
  438.                 if (S_IFDIR & dumb.d_fattr)    {
  439.                     chksrcbuf(DIRLEN);        /* check buf size */
  440.                     addfile(fixsrc, dumb.d_fname); /* add a dir into the path */
  441.                     strcat(bckslsh, fixsrc);
  442.                     chkdstbuf(DIRLEN);        /* check buf size */
  443.                     strcat(dumb.d_fname, fixdst);
  444.                     unpack(dumb.d_fname);
  445.                     strcpy(dumb.d_fname,
  446.                             ((TEDINFO *)(cpbox[CPDIR].ob_spec))->te_ptext);
  447.                     strcpy("_", ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext);
  448.                     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  449.                     objc_draw(cpbox, CPDIR, MAX_DEPTH, 0, 0, wdesk, hdesk);
  450.                     /* update check the dir existing or not */
  451.                     if ((code = chkdir(dumb.d_fname, cpbox)) == QUIT)    {
  452.                         Pterm(1);
  453.                     } else if (code == SKIP)    {
  454.                         backdir(fixsrc);
  455.                         backdir(fixdst);
  456.                         updatndir();
  457.                         srclen -= DIRLEN;        /* subtract the add lenth */
  458.                         dstlen -= DIRLEN;        /* subtract the add lenth */
  459.                         continue;
  460.                     }
  461.  
  462.                     if ((editdir) || (code == OK))    {
  463.                     recrtd:
  464.                         if (Dcreate(fixdst))    {
  465.                             if ((ret = err(cntcrtdr)) == 1)    {    /* skip */
  466.                                 backdir(fixsrc);
  467.                                 backdir(fixdst);
  468.                                 updatndir();
  469.                                 srclen -= DIRLEN;    /* subtract the add lenth */
  470.                                 dstlen -= DIRLEN;    /* subtract the add lenth */
  471.                                 continue;
  472.                             } else if (ret == 2)    {    /* retry */
  473.                                 goto recrtd;
  474.                             } else     {                    /* quit */
  475.                                 Pterm(1);
  476.                             }
  477.                         }
  478.                     }
  479.                     updatndir();
  480.                     strcat(bckslsh, fixdst);
  481.                     domvfd();                /* do the recursion */
  482.                     rmstarb(fixsrc);        /* after call, -> c:\d1\ */
  483.                 remvd:
  484.                     if (Ddelete(fixsrc))    { /* delete a dir */
  485.                         if ((ret = err(cntdeld)) == 2)    { /* retry */
  486.                             goto remvd;
  487.                         } else if (ret == 3)    {         /* abort */
  488.                             Pterm(1);
  489.                         }
  490.                     }
  491.                     backdir(fixsrc);        /* back one dir */
  492.                     backdir(fixdst);        /* back one dir */
  493.                     srclen -= DIRLEN;        /* subtract the add lenth */
  494.                     dstlen -= DIRLEN;        /* subtract the add lenth */
  495.  
  496.                 } else {
  497.                     chksrcbuf(FILELEN);        /* check buf size */
  498.                     addfile(fixsrc, dumb.d_fname);
  499.                     chkdstbuf(FILELEN);        /* check buf size */
  500.                     addfile(fixdst, dumb.d_fname);
  501.                     updatedir();
  502.                     /* update the file */
  503.                     unpack(dumb.d_fname); 
  504.                     strcpy(dumb.d_fname,
  505.                             ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext); 
  506.                     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  507.                     wrfile(fixsrc, fixdst);        /* cp one file to destination */
  508.                     /* rm the file from source */
  509.                 remvf:
  510.                     if (Fdelete(fixsrc))    {
  511.                         if ((ret = err(cntdelf)) == 2)    {    /* retry */
  512.                             goto remvf;
  513.                         } else if (ret == 3)    {            /* abort */
  514.                             Pterm(1);
  515.                         }
  516.                     }
  517.                     backdir(fixsrc);        /* back one dir */
  518.                     backdir(fixdst);        /* back one dir */
  519.                     srclen -= FILELEN;        /* subtract the add lenth */
  520.                     dstlen -= FILELEN;        /* subtract the add lenth */
  521.                 }
  522.             } 
  523.         } while (!Fsnext());
  524.     } else {
  525.         Pterm(1);
  526.     }
  527.     Fsetdta(saved);
  528.     return OK;
  529. }
  530.  
  531.  
  532. /* set the right drive and call the recursive routine to do the counting */
  533.  
  534.  
  535. count(s)
  536.  
  537. char *s;
  538.  
  539. {
  540.     char *buf, *tmp;
  541.     int drv;
  542.  
  543.     buf = (char *)Malloc((long)sizeof(s));
  544.     strcpy(s, buf);
  545.     tmp = buf;
  546.     drv = *buf;
  547.     if (drv >= 'a')        {
  548.         drv -= 'a';
  549.     } else {
  550.         drv -= 'A';
  551.     }
  552.     Dsetdrv(drv); 
  553.     while (*tmp)    {
  554.         tmp++;
  555.     }
  556.     if (*(tmp-1) == '*')    {
  557.         *(tmp-4) = '\0';
  558.         while(*buf != '\\')        {
  559.             buf++;
  560.         }
  561.         if (Dsetpath(buf))    {
  562.             Pterm(1);
  563.         }
  564.         countrec();
  565.     } else    {
  566.         numfiles = 1;
  567.     }
  568.     Mfree(buf);
  569.     return OK;
  570. }
  571.  
  572.  
  573. /* counte the file and directory recursivly */
  574.  
  575. countrec()
  576.  
  577.  
  578. {
  579.     char *saved;
  580.     DMABUFFER dumb;
  581.  
  582.     saved = (DMABUFFER *)Fgetdta();
  583.     Fsetdta(&dumb);
  584.     if (!Fsfirst(".\\*.*", 0xFF))    {
  585.         do     {
  586.             if (dumb.d_fname[0] != '.')    {
  587.                 if (S_IFDIR & dumb.d_fattr)    {
  588.                     /* setpath to one more down */
  589.                     if (Dsetpath(dumb.d_fname))    {
  590.                         Pterm(1);
  591.                     }
  592.                     numdirs++;
  593.                     countrec();        /* to the recursion */
  594.                     /* setpath to one back */
  595.                     if (Dsetpath(".\\.."))    {
  596.                         Pterm(1);
  597.                     }
  598.                 } else {
  599.                     numfiles++;
  600.                     tolsize += dumb.d_fsize;
  601.                 }
  602.             } 
  603.         } while (!Fsnext());
  604.     }
  605.     Fsetdta(saved);
  606.     return OK;
  607. }
  608.  
  609.  
  610. /* Copy the file from the s to d */
  611.  
  612. wrfile(s, d)
  613.  
  614. char *s, *d;
  615.  
  616. {
  617.     int code, ret, status;
  618.     int inhand;
  619.     int outhand;
  620.     DMABUFFER *mydta;
  621.     char *buffer, *saved;
  622.     long copysize;
  623.  
  624. open:
  625.  
  626.     if ((inhand = Fopen(s, 0)) < 0)    {
  627.         if ((inhand == 0xFFFA) || (inhand == 0xFFFE))    {/* seek error or */
  628.             Pterm(1);                                    /* drive not ready */
  629.         }
  630.         if ((ret = err(cntopen)) == 1)    {     /* skip */
  631.             return OK;
  632.         } else if (ret == 2)    {            /* retry */
  633.             goto open;
  634.         } else {                            /* abort */
  635.             Pterm(1);
  636.         }
  637.     }
  638.  
  639.     saved = (DMABUFFER *)Fgetdta();
  640.     Fsetdta(mydta=(DMABUFFER *)Malloc((long)sizeof(DMABUFFER)));
  641.  
  642.     if (Fsfirst(s, 0xF7))    {
  643.         if (err(rderror) == 1)    {     /* skip */
  644.             goto doup;
  645.         } else {                     /* abort */
  646.             Fclose(inhand);
  647.             Mfree(mydta);
  648.             Pterm(1);
  649.         }
  650.     }
  651.  
  652.     /* check the created file existing or not */
  653.     if ((code = chkfile(d, cpbox)) == QUIT)    {
  654.         Fclose(inhand);
  655.         Mfree(mydta);
  656.         Pterm(1);
  657.     } else if (code == SKIP)    {
  658.         goto doup;
  659.     }
  660.  
  661.     status = mydta->d_fattr & 7;
  662. create:
  663.  
  664.     if ((outhand = Fcreate(d, status)) < 0)    {
  665.         if ((ret = err(cntcrtfl)) == 1)    {    /* skip */
  666.             goto doup;
  667.         } else if (ret == 2)    {            /* retry */
  668.             goto create;
  669.         } else {                            /* abort */
  670.             Fclose(inhand);
  671.             Mfree(mydta);
  672.             Pterm(1);
  673.         }
  674.     }
  675.  
  676.     buffer = (char *)Malloc(8192L);
  677.     copysize = mydta->d_fsize;
  678.     while (copysize > 8192)    {
  679.         if (Fread(inhand, 8192L, buffer) < 0)    {
  680.             if (err(rderror) == 1)    {    /* skip */
  681.                 Fdelete(d);
  682.                 goto okup;
  683.             } else {                    /* abort */
  684.                 goto quitup;
  685.             }
  686.         }
  687.  
  688.         if ((status = Fwrite(outhand, 8192L, buffer)) < 0)    {
  689.             if (err(wrerror) == 1)    {    /* skip */
  690.                 Fdelete(d);
  691.                 goto okup;
  692.             } else {                    /* abort */
  693.                 goto quitup;
  694.             }
  695.         }
  696.         /* check if there are sufficent memory */
  697.         if (status != 8192)        { /* not sufficent memory ??*/
  698.             err(nomemory);
  699.             goto quitup;
  700.         }
  701.         copysize -= 8192;
  702.     }
  703.  
  704.     if (copysize > 0)    {
  705.         if (Fread(inhand, copysize, buffer) < 0)    {
  706.             if (err(rderror) == 1)    {        /* skip */
  707.                 Fdelete(d);
  708.                 goto okup;
  709.             } else {                        /* abort */
  710.                 goto quitup;
  711.             }
  712.         }
  713.  
  714.         if ((status = Fwrite(outhand, copysize, buffer)) < 0)    {
  715.             if (err(wrerror) == 1)    {    /* skip */
  716.                 Fdelete(d);
  717.                 goto okup;
  718.             } else {                    /* abort */
  719.                 goto quitup;
  720.             }
  721.         }
  722.         /* check if there are sufficent memory */
  723.         if (status != copysize)        {
  724.             /* update not sufficent memory ??*/
  725.             err(nomemory);
  726.             goto quitup;
  727.         }
  728.     }
  729.  
  730. okup:
  731.     Fclose(outhand);
  732.     Mfree(buffer);
  733.  
  734. doup:
  735.  
  736.     Fclose(inhand);
  737.     Mfree(mydta);
  738.     Fsetdta(saved);
  739.     updatnfile();
  740.     return(OK);
  741.  
  742. quitup:
  743.  
  744.     Fclose(inhand);
  745.     Fclose(outhand);
  746.     Fdelete(d);
  747.     Mfree(buffer);
  748.     Mfree(mydta);
  749.     Fsetdta(saved);
  750.     Pterm(1);
  751. }
  752.  
  753.  
  754. /* Copy s and d into fixsrc and fixdst. Also check it is one file
  755.    copy or files and directories copy */
  756.  
  757. getinfo(s, d, code)
  758.  
  759. char *s, *d;
  760. int code;
  761.  
  762. {
  763.  
  764.     int sdir=0, ddir=0;
  765.     char *ptrs, *ptrd;
  766.     extern char *strcat();
  767.  
  768.     ptrs = s;
  769.     ptrd = d;
  770.     srclen = strlen(s) + 5;     /* 1 for null and 4 for \*.* */
  771.     dstlen = strlen(d) + 5; 
  772.     srcbuf = 500;
  773.     dstbuf = 500;
  774.     while (srclen > srcbuf)    {
  775.         srcbuf *= 2;
  776.     }
  777.     while (dstlen > dstbuf)    {
  778.         dstbuf *= 2;
  779.     }
  780.     fixsrc = (char *)Malloc((long)srcbuf);
  781.     fixdst = (char *)Malloc((long)dstbuf);
  782.     mystrcp(fixsrc, &ptrs);    /* ptrs -> c:\d1\*.* or c:\d1\f; */
  783.                             /*after ptrs->*.* or f */
  784.     if (*ptrs == '*')    {    /* source are dir */
  785.         sdir = 1;
  786.     } 
  787.  
  788.     if (code)    {        /* do directories or files cp or mv */
  789.         mystrcp(fixdst, &ptrd);    /* ptrd -> c:\d1\*.* or c:\d1\f; */
  790.                                 /*after ptrd->*.* or f */
  791.         if (*ptrd == '*')    {    /* target are dir */
  792.             ddir = 1;
  793.         }
  794.         if ((sdir) && (ddir))    {                 /* dir to dir */
  795.             return (DTOD);
  796.         } else if ((!sdir) && (!ddir))    {         /* file to file */
  797.             return (FTOF);
  798.         } else {                                /* one file to dir */
  799.             chkdstbuf(FILELEN);                    /* check buf size */
  800.             strcat(ptrs, fixdst);
  801.             return (FTOD);
  802.         }
  803.     } else     {                    /* else do directories or files rm */
  804.         if (sdir)    {
  805.             return(DTOD);
  806.         } else {
  807.             return(FTOD);
  808.         }
  809.     }
  810. }
  811.  
  812.  
  813.  
  814.  
  815. /*  this call will copy the string inside the s to 
  816.  *     the fixs. For example,
  817.  *     if s -> c:\d1\d2\*.* or c:\d1\d2\f, after the call,
  818.  *    fixs -> \d1\d2\  or \d1\d2\f ; s -> *.* or f            */
  819.  
  820. mystrcp(fixs, s)
  821.  
  822. char *fixs;
  823. char **s;
  824.  
  825. {
  826.     char *ptr;
  827.  
  828.     ptr = *s;
  829.     while ((*ptr) && (*ptr != '*'))        {
  830.         *fixs++ = *ptr++;
  831.     }
  832.     *fixs = '\0';
  833.     if (*ptr == '*')        {
  834.         *s = ptr;
  835.     } else {
  836.         while (*ptr != '\\')    {
  837.             ptr--;
  838.         }
  839.         *s = ++ptr;
  840.     }
  841.  
  842. }
  843.  
  844.  
  845. /* check the size of source buffer */
  846.  
  847. chksrcbuf(addlen)
  848.  
  849. int addlen;
  850.  
  851. {
  852.  
  853.     char *ptr;
  854.  
  855.     if ((srclen + addlen) > srcbuf)        {
  856.         srcbuf *= 2;
  857.         ptr = fixsrc;
  858.         fixsrc = (char *)Malloc((long)srcbuf);
  859.         strcpy(ptr, fixsrc);
  860.         Mfree(ptr);
  861.     }
  862.     srclen += addlen;
  863. }
  864.  
  865.  
  866. /* check the size of target buffer */
  867.  
  868. chkdstbuf(addlen)
  869.  
  870. int addlen;
  871.  
  872. {
  873.  
  874.     char *ptr;
  875.  
  876.     if ((dstlen + addlen) > dstbuf)        {
  877.         dstbuf *= 2;
  878.         ptr = fixdst;
  879.         fixdst = (char *)Malloc((long)dstbuf);
  880.         strcpy(ptr, fixdst);
  881.         Mfree(ptr);
  882.     }
  883.     dstlen += addlen;
  884. }
  885.  
  886.  
  887. /* s -> c:\d1\d2\*.* or c:\d1\d2\, obj -> f; after the call
  888.  * s -> c:\d1\d2\f                            */
  889.  
  890. addfile(s, obj)
  891.  
  892. char *s, *obj;
  893.  
  894. {
  895.     char *ptr;
  896.     extern char *strcat();
  897.  
  898.     ptr = s;
  899.     while (*ptr)    {
  900.         ptr++;
  901.     }
  902.     if (*(ptr-1) == '*')    {
  903.         *(ptr-3) = '\0';
  904.     }
  905.     strcat(obj, s);
  906. }
  907.  
  908.  
  909.  
  910. /* src -> c:\d1\d2\*.* or -> c:\d3\d5\, after the call,
  911.  * src -> c:\d1\d2 or -> c:\d3\d5                        */
  912.  
  913. rmstarb(src)
  914.  
  915. char *src;
  916.  
  917. {
  918.  
  919.     char *ptr;
  920.  
  921.     ptr = src;
  922.     while (*ptr)        {
  923.         ptr++;
  924.     }
  925.     if (*(ptr-1) == '\\')    {    /* src -> c:\d3\d5\ */
  926.         *(ptr-1) = '\0';
  927.     } else {                    /* src -> c:\d3\d5\*.*  */
  928.         *(ptr-4) = '\0';
  929.     }
  930. }
  931.  
  932.  
  933.  
  934.  
  935. /* str -> c:\d1\d2\*.* or c:\d1\d2\ or c:\d2\d4; after the call,
  936.  * str -> c:\d1\*.* or c:\d1\  or c:\d2\        */
  937.  
  938. backdir(str)
  939.  
  940. char *str;
  941.  
  942. {
  943.     char *ptr;
  944.  
  945.     ptr = str;
  946.     while (*ptr)      {
  947.         ptr++;
  948.     }
  949.     if (*(ptr-1) == '*')    {        /* str -> c:\d1\d2\*.*    */
  950.         ptr -= 5;                    /* ptr -> 2 of c:\d1\d2 */
  951.         while (*ptr != '\\')    {
  952.             ptr--;
  953.         }
  954.         *ptr++;
  955.         *ptr++ = '*';
  956.         *ptr++ = '.';
  957.         *ptr++ = '*';
  958.         *ptr = '\0';
  959.     } else if (*(ptr-1) == '\\')        {    /* str -> c:\d1\d2\ */
  960.         ptr -= 2;
  961.         while (*ptr != '\\')    {
  962.             ptr--;
  963.         }
  964.         *(ptr + 1) = '\0';
  965.     } else     {                    /* str -> c:\d1\d2  */
  966.         while (*ptr != '\\')    {
  967.             ptr--;
  968.         }
  969.         *(ptr + 1) = '\0';
  970.     }
  971. }
  972.  
  973.  
  974.  
  975.  
  976. /* check the directory is exist or not */
  977.  
  978.  
  979. chkdir(dir, prvobjtree)
  980.  
  981. char *dir;
  982. OBJECT *prvobjtree;
  983.  
  984. {
  985.  
  986.     int ret, but, drv;
  987.     char *buf;
  988.  
  989.     buf = fixdst;
  990.     editdir = 0;
  991.  
  992.     drv = *buf;
  993.     if (drv >= 'a')        {
  994.         drv -= 'a';
  995.     } else {
  996.         drv -= 'A';
  997.     }
  998.     Dsetdrv(drv);
  999.     buf += 2;                /* set buf -> \d1\x */
  1000.     if (!(ret = Dsetpath(buf)))    {    /* direcory exist */
  1001.         /* update name conflict box */
  1002.         strcpy(dir, ((TEDINFO *)(samename[FNAME].ob_spec))->te_ptext);
  1003.         strcpy(dir, ((TEDINFO *)(samename[EDFNAME].ob_spec))->te_ptext);
  1004.         samename[COPY].ob_state = NORMAL;
  1005.         samename[SKIP].ob_state = NORMAL;
  1006.         samename[QUIT].ob_state = NORMAL;
  1007.         graf_mouse(ARROW, 0x0L);
  1008.         dsplymsg(samename);
  1009.         switch((but = form_do(samename, 0)))    {
  1010.             case COPY:    
  1011.                     if (!strcmp(((TEDINFO *)
  1012.                                 (samename[EDFNAME].ob_spec))->te_ptext, dir)) {
  1013.                         strcpy(
  1014.                         ((TEDINFO *)(samename[EDFNAME].ob_spec))->te_ptext,dir);
  1015.                         strcpy(dir,
  1016.                                 ((TEDINFO *)(cpbox[CPDIR].ob_spec))->te_ptext);
  1017.                         dopack(dir);
  1018.                         /* user edit the new name */
  1019.                         changelast(fixdst, dir);
  1020.                         editdir = 1;
  1021.                     }
  1022.                         break;
  1023.             case SKIP:    break;
  1024.             case QUIT:    break;
  1025.         }
  1026.         graf_mouse(HOURGLASS, 0x0L);
  1027.         dsplymsg(prvobjtree);
  1028.         return but;
  1029.     } else if (ret == 0xFFDE)    { /* path not found */
  1030.         return OK;
  1031.     } else {
  1032.         Pterm(1);
  1033.     }
  1034.  
  1035. }
  1036.  
  1037.  
  1038.  
  1039.  
  1040. /* check the file is exist or not */
  1041.  
  1042. chkfile(d, prvobjtree)
  1043.  
  1044. char *d;
  1045. OBJECT *prvobjtree;
  1046.  
  1047. {
  1048.  
  1049.     int ret, but;
  1050.  
  1051.     if ((ret = Fopen(d, 0)) >= 0)    {    /* file exist */
  1052.         /* update name conflict box */
  1053.         getlastpath(filestr, d);
  1054.         unpack(filestr);
  1055.         strcpy(filestr, ((TEDINFO *)(samename[FNAME].ob_spec))->te_ptext);
  1056.         strcpy(filestr, ((TEDINFO *)(samename[EDFNAME].ob_spec))->te_ptext);
  1057.         samename[COPY].ob_state = NORMAL;
  1058.         samename[SKIP].ob_state = NORMAL;
  1059.         samename[QUIT].ob_state = NORMAL;
  1060.         graf_mouse(ARROW, 0x0L);
  1061.         dsplymsg(samename);
  1062.         switch((but = form_do(samename, 0)))    {
  1063.             case COPY:    
  1064.                     if (!strcmp(filestr, 
  1065.                         ((TEDINFO *)(samename[EDFNAME].ob_spec))->te_ptext)) {
  1066.                         /* user edit the new name */
  1067.                         strcpy(
  1068.                         ((TEDINFO *)(samename[EDFNAME].ob_spec))->te_ptext,
  1069.                                                                     filestr);
  1070.                         strcpy(filestr,
  1071.                             ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext);
  1072.                         dopack(filestr);
  1073.                         changelast(d, filestr);
  1074.                     }
  1075.                         break;
  1076.             case SKIP:    break;
  1077.             case QUIT:    break;
  1078.         }
  1079.         graf_mouse(HOURGLASS, 0x0L);
  1080.         dsplymsg(prvobjtree);
  1081.         return but;
  1082.     } else if (ret == 0xFFDF)    {     /* file not found */
  1083.         return OK;
  1084.     } else {
  1085.         Pterm(1);
  1086.     }
  1087.  
  1088. }
  1089.  
  1090.  
  1091. /* if buf -> unpack.rsc, after the call, buf -> unpack  rsc.  */
  1092.  
  1093. unpack(buf)
  1094.  
  1095. char *buf;
  1096.  
  1097. {
  1098.     int i=0;
  1099.     char *ptr;
  1100.  
  1101.     ptr = buf;
  1102.     while ((*ptr != '.') && (*ptr))    {
  1103.         ptr++;
  1104.         i++;
  1105.     }
  1106.     if ((*ptr == '.') && (i != 8))    { /* src -> abcx.x */
  1107.         *(buf+11) = '\0';
  1108.         *(buf+10) = *(buf+i+3);
  1109.         *(buf+9) = *(buf+i+2);
  1110.         *(buf+8) = *(buf+i+1);
  1111.         for (; i < 8; i++)    {
  1112.             *(buf+i) = ' ';
  1113.         }
  1114.     } else if ((i == 8)    && (*ptr == '.'))     {    /* src -> abcdefgh.x */
  1115.         *(buf+8) = *(buf+9);
  1116.         *(buf+9) = *(buf+10);
  1117.         *(buf+10) = *(buf+11);
  1118.         *(buf+11) = '\0';
  1119.     }
  1120.  
  1121. }
  1122.  
  1123.  
  1124.  
  1125.  
  1126. /* src -> file    rsc, after the call;
  1127.    src -> file.rsc                        */
  1128.  
  1129. dopack(src)
  1130.  
  1131. char *src;
  1132.  
  1133. {
  1134.     char *ptr;
  1135.     int i=0;
  1136.  
  1137.     ptr = src;
  1138.     while ((*ptr != ' ') && (*ptr))    {
  1139.         ptr++;
  1140.         i++;
  1141.     }
  1142.     if (*ptr == ' ')    {
  1143.         *ptr++ = '.';
  1144.         *ptr++ = *(src+8);
  1145.         *ptr++ = *(src+9);
  1146.         *ptr++ = *(src+10);
  1147.         *ptr = '\0';
  1148.     } else if (i > 8)    {
  1149.         *(src+12) = '\0';
  1150.         *(src+11) = *(src+10);
  1151.         *(src+10) = *(src+9);
  1152.         *(src+9) = *(src+8);
  1153.         *(src+8) = '.';
  1154.     }
  1155. }
  1156.  
  1157.  
  1158. /* d -> c:\d1\d2\f1, name -> f2, after the call, d-> c:\d1\d2\f2     */
  1159.  
  1160. changelast(d, name)
  1161.  
  1162. char *d, *name;
  1163.  
  1164. {
  1165.     backdir(d);
  1166.     strcat(name, d);
  1167. }
  1168.  
  1169.  
  1170. /* src -> c:\d1\d2\ or c:\d1\ or c:\; or
  1171.    src -> c:\d1\d2\f or c:\d1\f or c:\f; after the call,
  1172.    buf -> d2 or d1 or c:\                                 */
  1173.  
  1174.  
  1175. getndlast(buf, src)
  1176.  
  1177. char *buf, *src;
  1178.  
  1179. {
  1180.     char *tmp;
  1181.  
  1182.     tmp = src;
  1183.     while (*tmp)    {
  1184.         tmp++;
  1185.     }
  1186.     tmp--;
  1187.     if (*tmp == '\\')    {    /* src -> c:\d1\d2\ or c:\d1\ or c:\ */
  1188.         if (*(tmp-1) == ':')    { /* src -> c:\ */
  1189.             while ((*buf++ = *src++) != '\\')    {
  1190.                 ;
  1191.             }
  1192.             *buf = '\0';
  1193.         } else {
  1194.             tmp--;
  1195.             while (*tmp != '\\')        {
  1196.                 tmp--;
  1197.             }
  1198.             tmp++;
  1199.             while ((*buf = *tmp++) != '\\')    {
  1200.                 buf++;
  1201.             }
  1202.             *buf = '\0';
  1203.         }
  1204.     } else {    /* src -> c:\d1\d2\f or c:\d1\f or c:\f */
  1205.         while (*tmp-- != '\\')        {
  1206.             ;
  1207.         }
  1208.         if (*tmp == ':')    { /* src -> c:\f */
  1209.             while ((*buf++ = *src++) != '\\')    {
  1210.                 ;
  1211.             }
  1212.             *buf = '\0';
  1213.         } else {    /* src -> c:\d1\d2\f or c:\d1\f */
  1214.             while (*tmp != '\\')        {
  1215.                 tmp--;
  1216.             }
  1217.             tmp++;
  1218.             while ((*buf = *tmp++) != '\\')    {
  1219.                 buf++;
  1220.             }
  1221.             *buf = '\0';
  1222.         }
  1223.     }
  1224. }
  1225.  
  1226.  
  1227.  
  1228. /* src -> c:\f or c:\d1\f or c:\f\, after the call,
  1229.    buf -> f                                 */
  1230.  
  1231. getlastpath(buf, src)
  1232.  
  1233. char *buf, *src;
  1234.  
  1235. {
  1236.     char *tmp;
  1237.  
  1238.     tmp = src;
  1239.     while (*tmp)    {
  1240.         tmp++;
  1241.     }
  1242.     if (*(tmp-1) == '\\')    {
  1243.         *(tmp-1) = '\0';
  1244.     }
  1245.     while (*tmp != '\\')        {
  1246.         tmp--;
  1247.     }
  1248.     tmp++;
  1249.     strcpy(tmp, buf);
  1250. }
  1251.  
  1252.  
  1253.  
  1254. /* draw the cp or mv or rm dialog box */
  1255.  
  1256. showbox(title)
  1257.  
  1258. char *title;
  1259.  
  1260. {
  1261.  
  1262.     itoa(numdirs, ((TEDINFO *)(cpbox[NUMDIR].ob_spec))->te_ptext);
  1263.     itoa(numfiles, ((TEDINFO *)(cpbox[NUMFILE].ob_spec))->te_ptext); 
  1264.     ((TEDINFO *)(cpbox[TITLE].ob_spec))->te_ptext = title;
  1265.     graf_mouse(ARROW, 0x0L);
  1266.     cpbox[HIDEBOX].ob_flags = HIDETREE;
  1267.     dsplymsg(cpbox);
  1268.     if (form_do(cpbox, 0) == CANCEL)    {
  1269.         return CANCEL;
  1270.     }
  1271.     cpbox[HIDEBOX].ob_flags = NORMAL;
  1272.     graf_mouse(HOURGLASS, 0x0L);
  1273.     return OK;
  1274.  
  1275. }
  1276.  
  1277. /* up date the number of file in the dialog box */
  1278.  
  1279. updatnfile()
  1280.  
  1281. {
  1282.  
  1283.     itoa(--numfiles, ((TEDINFO *)(cpbox[NUMFILE].ob_spec))->te_ptext);
  1284.     objc_draw(cpbox, NUMFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  1285. }
  1286.  
  1287. /* up date the number of directory in the dialog box */
  1288.  
  1289. updatndir()
  1290.  
  1291. {
  1292.  
  1293.     itoa(--numdirs, ((TEDINFO *)(cpbox[NUMDIR].ob_spec))->te_ptext);
  1294.     objc_draw(cpbox, NUMDIR, MAX_DEPTH, 0, 0, wdesk, hdesk);
  1295. }
  1296.  
  1297.  
  1298. /* up date the directory in the dialog box */
  1299.  
  1300.  
  1301. updatedir()
  1302.  
  1303. {
  1304.     getndlast(filestr, fixdst) ;
  1305.     unpack(filestr);
  1306.     strcpy(filestr, ((TEDINFO *)(cpbox[CPDIR].ob_spec))->te_ptext);
  1307.     objc_draw(cpbox, CPDIR, MAX_DEPTH, 0, 0, wdesk, hdesk);
  1308. }
  1309.  
  1310.  
  1311.  
  1312. /* up date the file in the dialog box */
  1313.  
  1314. updatefile()
  1315.  
  1316. {
  1317.     getlastpath(filestr, fixdst) ;
  1318.     unpack(filestr);
  1319.     strcpy(filestr, ((TEDINFO *)(cpbox[CPFILE].ob_spec))->te_ptext);
  1320.     objc_draw(cpbox, CPFILE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  1321.  
  1322. }
  1323.  
  1324.  
  1325.  
  1326. /* convert the integer to the ascci */
  1327.  
  1328. itoa(n, s)
  1329.  
  1330. char *s;
  1331. long n;
  1332.  
  1333. {
  1334.     int i=0, j=0;
  1335.     char tmp[10];
  1336.  
  1337.     do {
  1338.         tmp[i++] = n % 10 + '0';
  1339.     } while ((n /= 10) > 0);
  1340.     for (; i > 0; )    {
  1341.         *s++ = tmp[--i];
  1342.         j++;
  1343.     }
  1344.     for(; j < 4; j++)    {
  1345.         *s++ = ' ';
  1346.     }
  1347. }
  1348.  
  1349.  
  1350.  
  1351. /* get the dialog box string */
  1352.  
  1353. getalladdr()
  1354. {
  1355.  
  1356.     /* Error messages */
  1357.     if (!rsrc_gaddr(5, CNTOPEN, &cntopen)
  1358.         || !rsrc_gaddr(5, CNTCRTDR, &cntcrtdr)
  1359.         || !rsrc_gaddr(5, CNTCRTFL, &cntcrtfl)
  1360.         || !rsrc_gaddr(5, WRERROR, &wrerror)
  1361.         || !rsrc_gaddr(5, NOMEMORY, &nomemory)
  1362.         || !rsrc_gaddr(5, CNTDELF, &cntdelf)
  1363.         || !rsrc_gaddr(5, CNTDELD, &cntdeld)
  1364.         || !rsrc_gaddr(5, RDERROR, &rderror))
  1365.         return ERROR;
  1366.         
  1367.  
  1368.     if (!rsrc_gaddr(0, CPBOX, &cpbox)
  1369.         || !rsrc_gaddr(0, SAMENAME, &samename))    {
  1370.             return ERROR;
  1371.     }
  1372.     return OK;
  1373. }
  1374.  
  1375.  
  1376.  
  1377. /*
  1378.  *  Display a dialogue box on the screen.
  1379.  *    Input:
  1380.  *        tree - object tree for dialogue box to be displayed.
  1381.  *    Output:
  1382.  *        formw, formh, sx, sy, lx, ly - dimensions of box.
  1383.  */
  1384. dsplymsg(tree)
  1385. OBJECT *tree;
  1386. {
  1387.     form_center(tree,&lx, &ly, &formw, &formh);
  1388.     form_dial(1, 0, 0, 0, 0, lx, ly, formw, formh);
  1389.     objc_draw(tree, 0, MAX_DEPTH, 0, 0, wdesk, hdesk);
  1390. }
  1391.  
  1392.  
  1393. /*
  1394.  *  Erase a dialogue box from the screen.
  1395.  *    Input:
  1396.  *        formw, formh, sx, sy, lx, ly - dimensions of box.
  1397.  */
  1398. erasemsg()
  1399. {
  1400.     form_dial(3, 0, 0, 0, 0, lx, ly, formw, formh);
  1401. }
  1402.  
  1403.  
  1404.  
  1405.  
  1406. err(s)
  1407.  
  1408. char *s;
  1409.  
  1410. {
  1411.     int ret;
  1412.  
  1413.     graf_mouse(ARROW, 0x0L);
  1414.     ret = form_alert(1, s);
  1415.     graf_mouse(HOURGLASS, 0x0L);
  1416.     return (ret);
  1417. }
  1418.  
  1419.  
  1420.